Developer CD Series 1996 April: Mac OS SDK/Dev.CD Apr 96 SDK/Dev.CD Apr 96 SDK1.toast/Development Kits (Disc 1)/OpenDoc Development Framework/ODFDev/ODF/OS/FWFiles/Sources/FWFilPar.cpp

Text File | 1995-11-08 | 18.7 KB | 671 lines | [TEXT/MPS ]

//========================================================================================
//
//    File:        FWFilPar.cpp
//    Release Version:    $ 1.0d11 $
//
//    Copyright:    1995 by Apple Computer, Inc., all rights reserved.
//
//========================================================================================

#include "FWOS.hpp"

#ifndef FWFILPAR_H
#include "FWFilPar.h"
#endif

#ifndef FWFILESP_H
#include "FWFileSp.h"
#endif

#ifndef FWFILESY_H
#include "FWFileSy.h"
#endif

#ifndef FWSTRTOO_H
#include "FWStrToo.h"
#endif

#ifndef FWBNDSTR_H
#include "FWBndStr.h"
#endif

#ifndef FWEXCDEF_H
#include "FWExcDef.h"
#endif

#if defined(FW_BUILD_WIN) && !defined(FWMEMMGR_H)
#include "FWMemMgr.h"
#endif

#if defined(FW_BUILD_WIN) && !defined(__DOS_H)
#include <dos.h>
#endif

#if defined(FW_BUILD_WIN) && !defined(__DIRECT_H)
#include <direct.h>
#endif

#if defined(FW_BUILD_WIN) && !defined(__IO_H)
#include <io.h>
#endif

#if FW_LIB_EXPORT_PRAGMAS
#pragma lib_export on
#endif

#ifdef FW_BUILD_WIN16
extern "C" void FAR PASCAL DOS3Call();                // We don't do "int 21h" under Windows
#endif


//========================================================================================
// CLASS FW_CPrivFileSystemParser
//========================================================================================

//----------------------------------------------------------------------------------------
//    FW_CPrivFileSystemParser::IsPartialPath
//
//    Return TRUE if pathName specifies a partial pathName.
//
//  On Windows, only a fully qualified pathname will return FALSE.  That is a path that
//    specifies a drive and directory starting from the root directory of the drive.
//  On Mac, a partial pathname is any string that starts with a path separator character.
//----------------------------------------------------------------------------------------

FW_Boolean FW_CPrivFileSystemParser::IsPartialPath(const FW_CString& pathName)
{
    FW_Boolean result = TRUE;

#ifdef FW_BUILD_WIN
    if (pathName.GetLength() > 0)
    {
        FW_CString32 drivePathSeparator(&FW_kDriveDelimiter, 1);
        FW_CharacterPosition drivePosition;

        drivePathSeparator += FW_kPathDelimiter;

        if (pathName.FindSubString(drivePathSeparator, drivePosition))
            result = FALSE;
    }
#endif

#ifdef FW_BUILD_MAC
    if (pathName.GetLength() > 0)
        result = (pathName[0] == FW_kPathDelimiter);
#endif

    return (result);
}


//----------------------------------------------------------------------------------------
//    FW_CPrivFileSystemParser::AddDelimiter
//
//  Adds a trailing backslash if appropriate.  It will not add a delimiter if one already
//    exists, the path length is zero (indicating the default directory),or if the last
//    character is a colon (indicating a drive name).
//----------------------------------------------------------------------------------------

void FW_CPrivFileSystemParser::AddDelimiter(FW_CString& pathName)
{
    FW_CharacterPosition lastCharacter;

    lastCharacter = pathName.GetLength() - 1;

    if (lastCharacter >= 0)
    {
#ifdef FW_BUILD_WIN
        if ((pathName[lastCharacter] != FW_kPathDelimiter) && (pathName[lastCharacter] != FW_kDriveDelimiter))
            pathName += FW_kPathDelimiter;
#endif

#ifdef FW_BUILD_MAC
        if (pathName[lastCharacter] != FW_kPathDelimiter)
            pathName += FW_kPathDelimiter;
#endif

    }
}


#ifdef FW_BUILD_WIN16
//----------------------------------------------------------------------------------------
// PrivPrimitiveGetDefaultDrive
//
//  Return the current default drive number where A=0, B=1, C=2, etc.
//----------------------------------------------------------------------------------------
short FW_CPrivFileSystemParser::PrivPrimitiveGetDefaultDrive()
{
    short driveNumber = -1;

    __asm {
        mov        ah, 19h
    }

    DOS3Call();

    __asm {
        mov        driveNumber, ax
    }

    return (driveNumber);
}
#endif


#ifdef FW_BUILD_WIN16
//----------------------------------------------------------------------------------------
// PrivPrimitiveGetCurrentDir
//
//  namePtr is a pointer to a buffer.  On return, this buffer will contain the directory
//    name.  This buffer should be at least 64 bytes long.
//  Returns an error code.
//----------------------------------------------------------------------------------------
short FW_CPrivFileSystemParser::PrivPrimitiveGetCurrentDir(FW_Char* namePtr)
{
    FW_CFileSystem::FileError theError = FW_CFileSystem::kNoError;

    __asm {
        push    ds
        lds        si, [namePtr]
        mov        dl, 00h
        mov     ah, 47h
    }

    DOS3Call();

    __asm {
        pop     ds
        jc        _error
        xor     ax, ax
    }

    _error:

    __asm {
        mov        theError, ax
    }

    return (theError);
}
#endif


//----------------------------------------------------------------------------------------
// FW_CPrivFileSystemParser::PrivGetWorkingDirectory
//----------------------------------------------------------------------------------------

short FW_CPrivFileSystemParser::PrivGetWorkingDirectory(FW_CString& directoryName)
{
    FW_CFileSystem::FileError theError = FW_CFileSystem::kNoError;

    directoryName = "";

#ifdef FW_BUILD_WIN16
    FW_CString255 buffer;
    const FW_Char* namePtr = (const FW_Char*)buffer;
    short driveNumber = PrivPrimitiveGetDefaultDrive();

    directoryName = "";
    directoryName += (FW_Char)(driveNumber + 'a');
    directoryName += FW_kDriveDelimiter;
    directoryName += FW_kPathDelimiter;

    theError = PrivPrimitiveGetCurrentDir((FW_Char*)namePtr);
    if (theError == FW_CFileSystem::kNoError)
        directoryName += namePtr;
#endif

#ifdef FW_BUILD_WIN32
    char* dirBuffer = new char[MAX_PATH];
    long dirNameLength = ::GetCurrentDirectory(MAX_PATH, dirBuffer);

    if(dirNameLength == 0)
        theError = ::GetLastError();
    else
        directoryName = dirBuffer;

    delete [] dirBuffer;
#endif


#ifdef FW_BUILD_MAC
    short vRefNum;
    long dirID;

    theError = ::HGetVol(NULL, &vRefNum, &dirID);

    if (theError == FW_CFileSystem::kNoError)
        theError = MacGenerateFullPathName(vRefNum, dirID, directoryName);

#endif
    return (theError);
}


//----------------------------------------------------------------------------------------
//    FW_CPrivFileSystemParser::HasExtension
//
//  Return TRUE if the file name has a dot-extension.  Return the dot position in the
//    dotPosition parameter.
//    This routine searches the string backwards for the first path delimiter it sees.
//    It then searches the routine forwards searching for the first period it sees.
//    It returns TRUE if it finds the period.
//----------------------------------------------------------------------------------------

FW_Boolean FW_CPrivFileSystemParser::HasExtension(const FW_CString& fileName,
                                                    FW_CharacterPosition& dotPosition)
{
    FW_Boolean result = FALSE;
    FW_CharacterPosition pathDelimiterPosition;

    dotPosition = 0;

    if (fileName.GetLength() > 0)
    {
        FW_CStringTool *tool = FW_CStringTool::GetCurrentStringTool();
        result = tool->FindCharacter(fileName, FW_kPathDelimiter, pathDelimiterPosition, fileName.GetLength() - 1, FW_kBackwards);
        if (!result)
            pathDelimiterPosition = -1;

        result = tool->FindCharacter(fileName, FW_kExtensionDelimiter, dotPosition, pathDelimiterPosition + 1, FW_kForwards);
    }

    return (result);
}


//----------------------------------------------------------------------------------------
//    FW_CPrivFileSystemParser::ChangeExtension
//
//  Return a pathname with the specified extension attached.  fileName can be a full or
//    partial pathname.  If an extension already exists, it will be overwritten.
//----------------------------------------------------------------------------------------

void FW_CPrivFileSystemParser::ChangeExtension(const FW_CString& pathName,
                                                 const FW_CString& extension,
                                                 FW_CString& returnName)
{
    FW_CharacterPosition dotPosition;

    returnName = pathName;

    // If there is already an extension, trancate it and the dot.
    if (HasExtension(pathName, dotPosition))
        returnName.Truncate(dotPosition);

    returnName += FW_kExtensionDelimiter;
    returnName += extension;
}


//----------------------------------------------------------------------------------------
//    FW_CPrivFileSystemParser::GetExtension
//
//  Return the extension to this file in extension.  If no extension exists, then FALSE
//    is returned, otherwise TRUE is returned.
//----------------------------------------------------------------------------------------

FW_Boolean FW_CPrivFileSystemParser::GetExtension(const FW_CString& pathName,
                                                    FW_CString& extension)
{
    FW_CharacterPosition dotPosition;
    FW_Boolean result = FALSE;

    extension = "";

    // Delete everything before the extension, including the dot.
    if (HasExtension(pathName, dotPosition))
    {
        FW_Char charToAdd;

        FW_CStringReader reader(pathName);
        reader.SetPosition(dotPosition + 1);

        while ((charToAdd = reader.GetCharacterAndAdvance()) != FW_kNulCharacter)
            extension += charToAdd;

        result = TRUE;
    }

    return (result);
}


//----------------------------------------------------------------------------------------
//    FW_CPrivFileSystemParser::GetFileName
//
//  Return the filename portion without any path information.  The filename includes
//    the file extension.
//----------------------------------------------------------------------------------------

FW_Boolean FW_CPrivFileSystemParser::GetFileName(const FW_CString& pathName,
                                                   FW_CString& fileName)
{
    FW_CharacterPosition delimiterPosition;
    FW_Boolean result = FALSE;

    fileName = "";

    if (pathName.GetLength() > 0)
    {
        FW_CStringTool *tool = FW_CStringTool::GetCurrentStringTool();
        result = tool->FindCharacter(pathName, FW_kPathDelimiter, delimiterPosition, pathName.GetLength() - 1, FW_kBackwards);

#ifdef FW_BUILD_WIN
        // Only needed for Windows since path and drive delimiters are different.
        if (!result)
            result = tool->FindCharacter(pathName, FW_kDriveDelimiter, delimiterPosition, pathName.GetLength() - 1, FW_kBackwards);
#endif

        if (result)
        {
            FW_CStringReader reader(pathName);
            reader.SetPosition(delimiterPosition + 1);

            FW_Char charToAdd;
            while ((charToAdd = reader.GetCharacterAndAdvance()) != FW_kNulCharacter)
                fileName += charToAdd;
        }
    }
    else
        fileName = "";

    return (result);
}


//----------------------------------------------------------------------------------------
//    FW_CPrivFileSystemParser::GetJustFileName
//
//  Get the full file name and truncate off the dot and extension.
//----------------------------------------------------------------------------------------

FW_Boolean FW_CPrivFileSystemParser::GetJustFileName(const FW_CString& pathName,
                                                       FW_CString& fileName)
{
    FW_CharacterPosition dotPosition;

    FW_Boolean result = GetFileName(pathName, fileName);

    if (HasExtension(fileName, dotPosition))
        fileName.Truncate(dotPosition);

    return (result);
}




//===========================================
// Windows Routines
//===========================================

#ifdef FW_BUILD_WIN
//----------------------------------------------------------------------------------------
//    FW_CPrivFileSystemParser::WinGetPathName
//
//  Returns the directory information in pathName.  If the directory is anything but a root
//    directory, then there is no trailing backslash on the end of the path.  This makes
//    it easier to create FW_CDirectorySpecification's.
//  Returns FALSE if there is no path information, otherwise returns TRUE to indicate some
//    path information was present.  The information that gets returned may still be part
//    of a partial pathname.
//----------------------------------------------------------------------------------------

FW_Boolean FW_CPrivFileSystemParser::WinGetPathName(const FW_CString& fullPathName,
                                                   FW_CString& pathName)
{
    FW_CharacterPosition backSlashPosition = 0;
    FW_CharacterPosition colonPosition = 0;
    FW_CharacterPosition delimiterPosition;

    FW_Boolean backSlashResult = FALSE;
    FW_Boolean colonResult = FALSE;
    FW_Boolean functionResult = FALSE;

    pathName = "";

    if (fullPathName.GetLength() > 0)
    {
        // Search backwards for the first character in the delimiter set of '\' and ':'.
        FW_CStringTool *tool = FW_CStringTool::GetCurrentStringTool();

        backSlashResult = tool->FindCharacter(fullPathName, FW_kPathDelimiter, backSlashPosition, fullPathName.GetLength() - 1, FW_kBackwards);
        colonResult = tool->FindCharacter(fullPathName, FW_kDriveDelimiter, colonPosition, fullPathName.GetLength() - 1, FW_kBackwards);

        delimiterPosition = FW_Maximum(backSlashPosition, colonPosition);

        // If no delimiters were found, then there is no path information here.
        // Else return what path information there was.

        if (backSlashResult || colonResult)
        {
            if (delimiterPosition == 0)
                pathName += fullPathName[delimiterPosition];
            else
            {
                pathName = fullPathName;

                if (fullPathName[delimiterPosition] == FW_kPathDelimiter)
                {
                    // If the directory is the root directory, leave the trailing backslash.
                    //   Otherwise remove it.
                    if (fullPathName[(FW_CharacterPosition)(delimiterPosition - 1)] == FW_kDriveDelimiter)
                        pathName.Truncate(delimiterPosition + 1);
                    else
                        pathName.Truncate(delimiterPosition);
                }
                else
                    pathName.Truncate(delimiterPosition + 1);
            }

            functionResult = TRUE;
        }
    }

    return (functionResult);
}
#endif


#ifdef FW_BUILD_WIN
//----------------------------------------------------------------------------------------
//    FW_CPrivFileSystemParser::WinGetDrivePath
//
//  Returns the drive letter and colon character in drivePath if a drive was specified.
//    If no drive was specified, then FALSE is returned.  The program can use this to
//    determine whether or not pathName specifies a partial path.
//----------------------------------------------------------------------------------------

FW_Boolean FW_CPrivFileSystemParser::WinGetDrivePath(const FW_CString& pathName,
                                                    FW_CString& drivePath)
{
    FW_CharacterPosition delimiterPosition;
    FW_Boolean result = FALSE;

    drivePath = "";

    if (pathName.GetLength() > 0)
    {
        FW_CStringTool *tool = FW_CStringTool::GetCurrentStringTool();

        if (tool->FindCharacter(pathName, FW_kDriveDelimiter, delimiterPosition, pathName.GetLength() - 1, FW_kBackwards))
        {
            drivePath = pathName;
            drivePath.Truncate(delimiterPosition + 1);
            result = TRUE;
        }
    }

    return (result);
}
#endif


#ifdef FW_BUILD_WIN
//----------------------------------------------------------------------------------------
//    FW_CPrivFileSystemParser::WinExpandPartialPath
//
//  Expands a partial pathName into a full pathName based on the current drive and
//    directory.
//  On entry, pathName contains the partial pathname.
//  On exit, pathName contains the fully qualified pathname.
//----------------------------------------------------------------------------------------

void FW_CPrivFileSystemParser::WinExpandPartialPath(FW_CString& pathName)
{
    FW_CFileSystem::FileError theError = FW_CFileSystem::kNoError;
FW_UNUSED(theError);

#ifdef FW_BUILD_WIN16
    // [KVV] Instead of this tedious code, can use OpenFile(OF_PARSE…)

    if (IsPartialPath(pathName))
    {
        FW_CDynamicString drivePath;
        FW_CDynamicString tempPathName;

        if (WinGetDrivePath(pathName, drivePath))
        {
            // PathNames of form c:dir\file.ext are being phased out.  Do not use.
            FW_ASSERT(FALSE);
        }
        else
        {
            // Both these cases are built on top of the current directory or drive.
            PrivGetWorkingDirectory(tempPathName);

            if ((pathName.GetLength() > 0) && (pathName[0] == FW_kPathDelimiter))
            {
                // In this case, the path is in the form '\dir1\file.txt'
                //   So all we need to do is add the drive.
                WinGetDrivePath(tempPathName, drivePath);

                pathName.Prepend(drivePath);
            }
            else
            {
                // In this case, the path is in the form 'dir1\file.txt'
                //   So we need to add the current working directory.
                if (pathName.GetLength() > 0)
                {
                    AddDelimiter(tempPathName);
                    tempPathName += pathName;
                }

                pathName = tempPathName;
            }
        }
    }
#endif

#ifdef FW_BUILD_WIN32
    // ??? This may or may not be a valid thing to do on Win32.  It needs to be verified.

    char* nameBuffer = new char[MAX_PATH];
    char* filePortion;

    long bufferSize = ::GetFullPathName((const FW_Char*)pathName, MAX_PATH, nameBuffer, &filePortion);

    // Errors are getting eaten for now.  But I still want to see them when
    //   debugging - jjw 8/12/93
    if (bufferSize == 0)
        theError = ::GetLastError();
    else
        pathName = nameBuffer;

    delete nameBuffer;
#endif
}
#endif


//===========================================
// Macintosh Routines
//===========================================

#ifdef FW_BUILD_MAC
//----------------------------------------------------------------------------------------
//    FW_CPrivFileSystemParser::MacGenerateFullPathName
//
//    Generate a pathname based on the vRefNum and dirID passed to the function.  Return
//    TRUE if pathName contains a valid path including volume name.  If this routine
//    returns FALSE, the contents of pathName are undefined.
//----------------------------------------------------------------------------------------

OSErr FW_CPrivFileSystemParser::MacGenerateFullPathName(short vRefNum,
                                                            long dirID,
                                                            FW_CString& pathName)
{
    CInfoPBRec paramBlock;
    Str255 dirName = "\p";
    OSErr theError = noErr;
    FW_CDynamicString tempString;

    // Casts required for compilation.
    paramBlock.dirInfo.ioNamePtr = (StringPtr) &dirName;
    paramBlock.dirInfo.ioVRefNum = vRefNum;
    paramBlock.dirInfo.ioDrParID = dirID;
    paramBlock.dirInfo.ioFDirIndex = -1;

    do
    {
        paramBlock.dirInfo.ioDrDirID = paramBlock.dirInfo.ioDrParID;

        theError = ::PBGetCatInfoSync(¶mBlock);
        if (theError != noErr)
            return (theError);

        // Casts required for compilation.
        tempString.ReplaceAll((FW_PascalChar*)&dirName);
        tempString += ":";
        tempString += pathName;
        pathName = tempString;
    } while (paramBlock.dirInfo.ioDrDirID != fsRtDirID);

    return (noErr);
}
#endif


#ifdef FW_BUILD_MAC
//----------------------------------------------------------------------------------------
//    FW_CPrivFileSystemParser::MacGenerateDirectory
//
//    Get the name of the directory specified
//----------------------------------------------------------------------------------------

OSErr FW_CPrivFileSystemParser::MacGenerateDirectory(short vRefNum,
                                                         long dirID,
                                                         FW_CDirectorySpecification& directory)
{
    CInfoPBRec paramBlock;
    Str255 dirName = "\p";
    OSErr theError = noErr;
    FSSpec theMacSpec;

    // Casts required for compilation.
    paramBlock.dirInfo.ioNamePtr = (StringPtr) & dirName;
    paramBlock.dirInfo.ioVRefNum = vRefNum;
    paramBlock.dirInfo.ioDrParID = dirID;
    paramBlock.dirInfo.ioFDirIndex = -1;

    paramBlock.dirInfo.ioDrDirID = paramBlock.dirInfo.ioDrParID;

    theError = ::PBGetCatInfoSync(¶mBlock);
    if (theError != noErr)
        return (theError);

    theError = ::FSMakeFSSpec(vRefNum, paramBlock.dirInfo.ioDrParID, dirName, &theMacSpec);

    if (theError != noErr)
        return (theError);

    directory = theMacSpec;
    return (noErr);
}
#endif